/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.agtranscontinental.sisref.commons;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 *
 * @author ericson
 */
public class Archivo implements Serializable {

    public static ZipOutputStream zos;

    public boolean guardarArchivo(byte[] bit, String ruta) {
        boolean est = false;
        OutputStream out;
        try {
            out = new FileOutputStream(ruta);
            out.write(bit, 0, bit.length);
            out.flush();
            out.close();
            est = true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return est;
    }

    public boolean copiarArchivo(String destino, String origen) {
        boolean est = false;
        try {
            File inFile = new File(origen);
            File outFile = new File(destino);
            FileInputStream in = new FileInputStream(inFile);
            FileOutputStream out = new FileOutputStream(outFile);
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
            in.close();
            out.close();
        } catch (IOException e) {
        }
        return est;
    }

    public boolean ifExistFile(String carpeta, String fichero) {
        File file = new File(carpeta + fichero);
        return file.exists();
    }

    public static String obtenerExtension(String archivo) {
        int indexOf = archivo.lastIndexOf(".");
        return archivo.substring(indexOf + 1);
    }

    public byte[] obtenerBytes(InputStream is, int tope) {
        DataInputStream dis = new DataInputStream(is);
        byte[] bytes = new byte[tope];
        try {
            dis.readFully(bytes);
            if (dis != null) {
                dis.close();
                is.close();
            }
        } catch (java.io.IOException ioe) {
            ioe.printStackTrace();
        }
        return bytes;
    }

    public int comprimirArchivo(String path, String extension) {
        try {
            path = path.substring(0, path.length() - 1);
            comprimir(path, extension);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
        return 1;
    }

    private static void comprimir(String path, String extension) throws IOException, FileNotFoundException {
        File file = new File(path);

        zos = new ZipOutputStream(new FileOutputStream(path + extension));
        recursiveFiles(file);
        zos.close();
    }

    private static void comprimir(String path, String extension, ArrayList<String> names) throws IOException, FileNotFoundException {
        File file = new File(path);

        zos = new ZipOutputStream(new FileOutputStream(path + extension));
        recursiveFiles(file, names);
        zos.close();
    }

    private static void recursiveFiles(File file) throws IOException, FileNotFoundException {
        if (file.isDirectory()) {
            String listaArchivos[] = file.list();
            if (listaArchivos != null) {
                for (int i = 0; i < listaArchivos.length; i++) {
                    recursiveFiles(new File(file, listaArchivos[i]));
                }
            }
        } else {
            byte[] buf = new byte[1024];
            int len;
            String nombreArchivo = file.toString().substring(file.toString().lastIndexOf("\\") + 1);
            ZipEntry zipEntry = new ZipEntry(nombreArchivo);
            FileInputStream fin = new FileInputStream(file);
            BufferedInputStream in = new BufferedInputStream(fin);
            zos.putNextEntry(zipEntry);
            while ((len = in.read(buf)) >= 0) {
                zos.write(buf, 0, len);
            }
            in.close();
            zos.closeEntry();
        }
    }

    private static void recursiveFiles(File file, ArrayList<String> nameFiles) throws IOException, FileNotFoundException {
        if (file.isDirectory()) {
            String listaArchivos[] = file.list();
            if (listaArchivos != null) {
                for (int i = 0; i < listaArchivos.length; i++) {
                    recursiveFiles(new File(file, listaArchivos[i]), nameFiles);
                }
            }
        } else {
            String nombreArchivo = file.toString().substring(file.toString().lastIndexOf("\\") + 1);
            if (isInnerName(nombreArchivo, nameFiles)) {
                byte[] buf = new byte[1024];
                int len;
                ZipEntry zipEntry = new ZipEntry(nombreArchivo);
                FileInputStream fin = new FileInputStream(file);
                BufferedInputStream in = new BufferedInputStream(fin);
                zos.putNextEntry(zipEntry);
                while ((len = in.read(buf)) >= 0) {
                    zos.write(buf, 0, len);
                }
                in.close();
                zos.closeEntry();
            }
        }
    }

    public static boolean isInnerName(String name, ArrayList<String> names) {
        for (String n : names) {
            if (n.equals(name)) {
                return true;
            }
        }
        return false;
    }

    public void guardarArchivo(byte[] data, String path, String fileName) {
        OutputStream out;
        File file = new File(path);
        file.mkdirs();
        try {
            out = new FileOutputStream(path + fileName);
            out.write(data);

            out.flush();
            out.close();
            data = new byte[1];
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public int descomprimirArchivo(String path, String formato) {
        BufferedOutputStream bos = null;
        FileInputStream fis;

        String rutaGuardado = path.substring(0, path.lastIndexOf(formato)) + "\\";
        //Creando la carpeta de descomprimir
        File file = new File(rutaGuardado);
        file.mkdir();

        try {
            fis = new FileInputStream(path);
            ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
            ZipEntry ze;

            while ((ze = zis.getNextEntry()) != null) {
                int count = 0;
                byte data[] = new byte[2048];
                String nombreArchivo = rutaGuardado + ze.getName();
                FileOutputStream fos = new FileOutputStream(nombreArchivo);
                bos = new BufferedOutputStream(fos, 2048);
                while ((count = zis.read(data, 0, 2048)) != -1) {
                    bos.write(data, 0, count);
                }
                fos.close();
                bos.close();
            }
            zis.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return 0;
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }

    public void escribirArchivo(String path, String carpeta, String nombreFichero, String cadena) {
        FileWriter fichero = null;
        PrintWriter pw = null;
        System.out.println("Longitud total de la cadena" + cadena.length());
        try {
            File file = new File(path + carpeta);
            if (file.exists()) {
                fichero = new FileWriter(path + carpeta + nombreFichero, true);
            } else {
                file.mkdirs();
                fichero = new FileWriter(path + carpeta + nombreFichero);
            }
            pw = new PrintWriter(fichero);
            pw.print(cadena);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fichero != null) {
                    fichero.close();
                    pw.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

    public void eliminarArchivo(String path) {
        File file = new File(path);
        if (file.exists()) {
            eliminarArchivo(file);
        }
    }

    public boolean eliminarArchivo(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                eliminarArchivo(files[i]);
            }
        } else {
            return file.delete();
        }
        return file.delete();
    }
}
